home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / quotaops.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  8KB  |  247 lines
  1. /*
  2.  * Definitions for diskquota-operations. When diskquota is configured these
  3.  * macros expand to the right source-code.
  4.  *
  5.  * Author:  Marco van Wieringen <mvw@planets.elm.net>
  6.  *
  7.  * Version: $Id: quotaops.h,v 1.2 1998/01/15 16:22:26 ecd Exp $
  8.  *
  9.  */
  10. #ifndef _LINUX_QUOTAOPS_
  11. #define _LINUX_QUOTAOPS_
  12.  
  13. #include <linux/config.h>
  14. #include <linux/smp_lock.h>
  15.  
  16. #include <linux/fs.h>
  17.  
  18. #if defined(CONFIG_QUOTA)
  19.  
  20. /*
  21.  * declaration of quota_function calls in kernel.
  22.  */
  23. extern void sync_dquots(struct super_block *sb, int type);
  24.  
  25. extern int dquot_initialize(struct inode *inode, int type);
  26. extern int dquot_drop(struct inode *inode);
  27.  
  28. extern int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
  29. extern int dquot_alloc_inode(const struct inode *inode, unsigned long number);
  30.  
  31. extern int dquot_free_space(struct inode *inode, qsize_t number);
  32. extern int dquot_free_inode(const struct inode *inode, unsigned long number);
  33.  
  34. extern int dquot_transfer(struct inode *inode, struct iattr *iattr);
  35. extern int dquot_commit(struct dquot *dquot);
  36. extern int dquot_acquire(struct dquot *dquot);
  37. extern int dquot_release(struct dquot *dquot);
  38. extern int dquot_commit_info(struct super_block *sb, int type);
  39. extern int dquot_mark_dquot_dirty(struct dquot *dquot);
  40.  
  41. extern int vfs_quota_on(struct super_block *sb, int type, int format_id, char *path);
  42. extern int vfs_quota_on_mount(int type, int format_id, struct dentry *dentry);
  43. extern int vfs_quota_off(struct super_block *sb, int type);
  44. #define vfs_quota_off_mount(sb, type) vfs_quota_off(sb, type)
  45. extern int vfs_quota_sync(struct super_block *sb, int type);
  46. extern int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  47. extern int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
  48. extern int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  49. extern int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
  50.  
  51. /*
  52.  * Operations supported for diskquotas.
  53.  */
  54. extern struct dquot_operations dquot_operations;
  55. extern struct quotactl_ops vfs_quotactl_ops;
  56.  
  57. #define sb_dquot_ops (&dquot_operations)
  58. #define sb_quotactl_ops (&vfs_quotactl_ops)
  59.  
  60. /* It is better to call this function outside of any transaction as it might
  61.  * need a lot of space in journal for dquot structure allocation. */
  62. static __inline__ void DQUOT_INIT(struct inode *inode)
  63. {
  64.     BUG_ON(!inode->i_sb);
  65.     if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
  66.         inode->i_sb->dq_op->initialize(inode, -1);
  67. }
  68.  
  69. /* The same as with DQUOT_INIT */
  70. static __inline__ void DQUOT_DROP(struct inode *inode)
  71. {
  72.     /* Here we can get arbitrary inode from clear_inode() so we have
  73.      * to be careful. OTOH we don't need locking as quota operations
  74.      * are allowed to change only at mount time */
  75.     if (!IS_NOQUOTA(inode) && inode->i_sb && inode->i_sb->dq_op
  76.         && inode->i_sb->dq_op->drop) {
  77.         int cnt;
  78.         /* Test before calling to rule out calls from proc and such
  79.                  * where we are not allowed to block. Note that this is
  80.          * actually reliable test even without the lock - the caller
  81.          * must assure that nobody can come after the DQUOT_DROP and
  82.          * add quota pointers back anyway */
  83.         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
  84.             if (inode->i_dquot[cnt] != NODQUOT)
  85.                 break;
  86.         if (cnt < MAXQUOTAS)
  87.             inode->i_sb->dq_op->drop(inode);
  88.     }
  89. }
  90.  
  91. /* The following allocation/freeing/transfer functions *must* be called inside
  92.  * a transaction (deadlocks possible otherwise) */
  93. static __inline__ int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
  94. {
  95.     if (sb_any_quota_enabled(inode->i_sb)) {
  96.         /* Used space is updated in alloc_space() */
  97.         if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
  98.             return 1;
  99.     }
  100.     else
  101.         inode_add_bytes(inode, nr);
  102.     return 0;
  103. }
  104.  
  105. static __inline__ int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
  106. {
  107.     int ret;
  108.         if (!(ret =  DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr)))
  109.         mark_inode_dirty(inode);
  110.     return ret;
  111. }
  112.  
  113. static __inline__ int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
  114. {
  115.     if (sb_any_quota_enabled(inode->i_sb)) {
  116.         /* Used space is updated in alloc_space() */
  117.         if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
  118.             return 1;
  119.     }
  120.     else
  121.         inode_add_bytes(inode, nr);
  122.     return 0;
  123. }
  124.  
  125. static __inline__ int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
  126. {
  127.     int ret;
  128.     if (!(ret = DQUOT_ALLOC_SPACE_NODIRTY(inode, nr)))
  129.         mark_inode_dirty(inode);
  130.     return ret;
  131. }
  132.  
  133. static __inline__ int DQUOT_ALLOC_INODE(struct inode *inode)
  134. {
  135.     if (sb_any_quota_enabled(inode->i_sb)) {
  136.         DQUOT_INIT(inode);
  137.         if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
  138.             return 1;
  139.     }
  140.     return 0;
  141. }
  142.  
  143. static __inline__ void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
  144. {
  145.     if (sb_any_quota_enabled(inode->i_sb))
  146.         inode->i_sb->dq_op->free_space(inode, nr);
  147.     else
  148.         inode_sub_bytes(inode, nr);
  149. }
  150.  
  151. static __inline__ void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
  152. {
  153.     DQUOT_FREE_SPACE_NODIRTY(inode, nr);
  154.     mark_inode_dirty(inode);
  155. }
  156.  
  157. static __inline__ void DQUOT_FREE_INODE(struct inode *inode)
  158. {
  159.     if (sb_any_quota_enabled(inode->i_sb))
  160.         inode->i_sb->dq_op->free_inode(inode, 1);
  161. }
  162.  
  163. static __inline__ int DQUOT_TRANSFER(struct inode *inode, struct iattr *iattr)
  164. {
  165.     if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode)) {
  166.         DQUOT_INIT(inode);
  167.         if (inode->i_sb->dq_op->transfer(inode, iattr) == NO_QUOTA)
  168.             return 1;
  169.     }
  170.     return 0;
  171. }
  172.  
  173. /* The following two functions cannot be called inside a transaction */
  174. #define DQUOT_SYNC(sb)    sync_dquots(sb, -1)
  175.  
  176. static __inline__ int DQUOT_OFF(struct super_block *sb)
  177. {
  178.     int ret = -ENOSYS;
  179.  
  180.     if (sb_any_quota_enabled(sb) && sb->s_qcop && sb->s_qcop->quota_off)
  181.         ret = sb->s_qcop->quota_off(sb, -1);
  182.     return ret;
  183. }
  184.  
  185. #else
  186.  
  187. /*
  188.  * NO-OP when quota not configured.
  189.  */
  190. #define sb_dquot_ops                (NULL)
  191. #define sb_quotactl_ops                (NULL)
  192. #define sync_dquots_dev(dev,type)        (NULL)
  193. #define DQUOT_INIT(inode)            do { } while(0)
  194. #define DQUOT_DROP(inode)            do { } while(0)
  195. #define DQUOT_ALLOC_INODE(inode)        (0)
  196. #define DQUOT_FREE_INODE(inode)            do { } while(0)
  197. #define DQUOT_SYNC(sb)                do { } while(0)
  198. #define DQUOT_OFF(sb)                do { } while(0)
  199. #define DQUOT_TRANSFER(inode, iattr)        (0)
  200. extern __inline__ int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
  201. {
  202.     inode_add_bytes(inode, nr);
  203.     return 0;
  204. }
  205.  
  206. extern __inline__ int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
  207. {
  208.     DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr);
  209.     mark_inode_dirty(inode);
  210.     return 0;
  211. }
  212.  
  213. extern __inline__ int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
  214. {
  215.     inode_add_bytes(inode, nr);
  216.     return 0;
  217. }
  218.  
  219. extern __inline__ int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
  220. {
  221.     DQUOT_ALLOC_SPACE_NODIRTY(inode, nr);
  222.     mark_inode_dirty(inode);
  223.     return 0;
  224. }
  225.  
  226. extern __inline__ void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
  227. {
  228.     inode_sub_bytes(inode, nr);
  229. }
  230.  
  231. extern __inline__ void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
  232. {
  233.     DQUOT_FREE_SPACE_NODIRTY(inode, nr);
  234.     mark_inode_dirty(inode);
  235. }    
  236.  
  237. #endif /* CONFIG_QUOTA */
  238.  
  239. #define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr)    DQUOT_PREALLOC_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
  240. #define DQUOT_PREALLOC_BLOCK(inode, nr)    DQUOT_PREALLOC_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
  241. #define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) DQUOT_ALLOC_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
  242. #define DQUOT_ALLOC_BLOCK(inode, nr) DQUOT_ALLOC_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
  243. #define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) DQUOT_FREE_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
  244. #define DQUOT_FREE_BLOCK(inode, nr) DQUOT_FREE_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
  245.  
  246. #endif /* _LINUX_QUOTAOPS_ */
  247.